package school

import (
	"ser1/utils"
	"time"

	"github.com/gin-gonic/gin"
)

// AddQuestion godoc
// @Summary 添加问题
// @Description 添加新问题
// @Tags 答题管理
// @Accept json
// @Produce json
// @Param question body Question true "问题信息"
// @Success 200 {object} utils.Response
// @Router /school/question/add [post]
func AddQuestion(c *gin.Context) {
	var dto QuestionDto
	if err := c.ShouldBindJSON(&dto); err != nil {
		utils.ResponseError(c, 1, "参数错误")
		return
	}
	question := dto.toModel()
	if err := DB1().Omit("answer").Create(&question).Error; err != nil {
		utils.ResponseError(c, 1, "添加失败")
		return
	}

	utils.ResponseSuccess(c, question.ID)
}

// GetQuestions godoc
// @Summary 获取问题列表
// @Description 获取所有问题列表
// @Tags 答题管理
// @Accept json
// @Produce json
// @Param category query string false "分类"
// @Success 200 {object} utils.Response
// @Router /school/questions [get]
func GetQuestions(c *gin.Context) {
	var questions []Question
	category := c.Query("category")

	db := DB1()
	if category != "" {
		db = db.Where("category = ?", category)
	}

	if err := db.Find(&questions).Error; err != nil {
		utils.ResponseError(c, 1, "获取失败")
		return
	}

	utils.ResponseSuccess(c, questions)
}

// SubmitAnswer godoc
// @Summary 提交答案
// @Description 提交问题答案
// @Tags 答题管理
// @Accept json
// @Produce json
// @Param answer body Answer true "答案信息"
// @Success 200 {object} utils.Response
// @Router /school/answer/submit [post]
func SubmitAnswer(c *gin.Context) {
	var answer Answer
	if err := c.ShouldBindJSON(&answer); err != nil {
		utils.ResponseError(c, 1, "参数错误")
		return
	}

	// 简单的答案验证逻辑
	var question Question
	if err := DB1().First(&question, answer.QuestionID).Error; err != nil {
		utils.ResponseError(c, 1, "问题不存在")
		return
	}

	// 检查答案是否正确
	answer.IsCorrect = (question.Answer == answer.Content)
	if answer.IsCorrect {
		answer.Score = 10 // 简单设定满分10分
	}

	if err := DB1().Create(&answer).Error; err != nil {
		utils.ResponseError(c, 1, "提交失败")
		return
	}

	utils.ResponseSuccess(c, answer.ID)
}

// GetQuestion godoc
// @Summary 获取问题详情
// @Description 根据ID获取问题详情
// @Tags 答题管理
// @Accept json
// @Produce json
// @Param id path int true "问题ID"
// @Success 200 {object} utils.Response
// @Router /school/question/{id} [get]
func GetQuestion(c *gin.Context) {
	id := c.Param("id")
	var question Question
	if err := DB1().First(&question, id).Error; err != nil {
		utils.ResponseError(c, 1, "问题不存在")
		return
	}

	utils.ResponseSuccess(c, question)
}

// UpdateQuestion godoc
// @Summary 更新问题
// @Description 根据ID更新问题
// @Tags 答题管理
// @Accept json
// @Produce json
// @Param id path int true "问题ID"
// @Param question body Question true "问题信息"
// @Success 200 {object} utils.Response
// @Router /school/question/{id} [put]
func UpdateQuestion(c *gin.Context) {
	id := c.Param("id")
	var dto QuestionDto
	if err := c.ShouldBindJSON(&dto); err != nil {
		utils.ResponseError(c, 1, "参数错误")
		return
	}

	var question Question
	if err := DB1().First(&question, id).Error; err != nil {
		utils.ResponseError(c, 1, "问题不存在")
		return
	}

	// 更新问题信息
	question.Title = dto.Title
	question.Content = utils.ToJson(dto.Content)
	question.Answer = dto.Answer
	question.Category = dto.Category
	question.Difficulty = dto.Difficulty
	question.GroupId = dto.GroupId
	question.Tags = dto.Tags

	if err := DB1().Save(&question).Error; err != nil {
		utils.ResponseError(c, 1, "更新失败")
		return
	}

	utils.ResponseSuccess(c, question.ID)
}

// DeleteQuestion godoc
// @Summary 删除问题
// @Description 根据ID删除问题
// @Tags 答题管理
// @Accept json
// @Produce json
// @Param id path int true "问题ID"
// @Success 200 {object} utils.Response
// @Router /school/question/{id} [delete]
func DeleteQuestion(c *gin.Context) {
	id := c.Param("id")
	
	if err := DB1().Delete(&Question{}, id).Error; err != nil {
		utils.ResponseError(c, 1, "删除失败")
		return
	}

	utils.ResponseSuccess(c, "删除成功")
}

// GetQuestionGroup godoc
// @Summary 获取问题分组列表
// @Description 获取所有问题分组列表
// @Tags 答题管理
// @Accept json
// @Produce json
// @Success 200 {object} utils.Response
// @Router /school/question/group [get]
func GetQuestionGroup(c *gin.Context) {
	var groups []QuestionGroup
	
	if err := DB1().Find(&groups).Error; err != nil {
		utils.ResponseError(c, 1, "获取失败")
		return
	}

	utils.ResponseSuccess(c, groups)
}

type cDto struct {
	Num        int    `json:"num" binding:"required"`
	Difficulty uint   `json:"difficulty" binding:"required"`
	GroupName  string `json:"group_name" binding:"required"`
}

func createAnswerGroup(c *gin.Context) {
	var dto cDto
	if err := c.ShouldBindJSON(&dto); err != nil {
		utils.PrarmError(c)
		return
	}
	userId := utils.GetUserId(c)
	var questions []Question
	sqlobj := DB1()

	if dto.Difficulty != 0 {
		sqlobj = sqlobj.Where("difficulty = ?", dto.Difficulty)
	}
	//随机获取一定数量的问题
	err := sqlobj.Where("status = ?", 1).Order("RAND()").Limit(dto.Num).Find(&questions).Error
	if err != nil {
		utils.ResponseError(c, 500, "获取失败")
		return
	}
	now := time.Now()
	answerGroup := AnswerGroup{
		Name:       dto.GroupName,
		UserID:     userId,
		Expiration: now.Add(30 * time.Minute),
	}
	if err := DB1().Create(&answerGroup).Error; err != nil {
		utils.ResponseError(c, 500, "创建失败")
		return
	}

	//通过循环获取id
	for _, question := range questions {
		answer := Answer{
			QuestionID: question.ID,
			UserID:     userId,
			GroupId:    answerGroup.ID,
		}
		DB1().Create(&answer)

	}

	utils.ResponseSuccess(c, answerGroup.ID)
}

func getAnswerGroup(c *gin.Context) {
	idstr := c.Param("id")
	//转uint
	id := utils.ToUint(idstr)
	res, err := getAnswerGroupFun(id, 0, 0)
	if err != nil {
		utils.ResponseError(c, 500, "获取失败")
		return
	}
	utils.ResponseSuccess(c, res)
}

func getAnswerMyGroup(c *gin.Context) {
	userId := utils.GetUserId(c)
	res, err := getAnswerGroupFun(0, userId, 0)
	if err != nil {
		utils.ResponseError(c, 500, "获取失败")
		return
	}
	utils.ResponseSuccess(c, res)
}

func createQuestionGroup(c *gin.Context) {
	var g QuestionGroup
	if err := c.ShouldBindJSON(&g); err != nil {
		utils.PrarmError(c)
		return
	}
	if err := DB1().Create(&g).Error; err != nil {
		utils.ResponseError(c, 500, "创建失败")
		return
	}
	utils.ResponseSuccess(c, g.ID)
}
